16.3 Auswahlkästchen mit der Klasse »CheckBox«
 
Die zweite aus ButtonBase abgeleitete Klasse ist CheckBox. Objekte dieses Typs werden auch als Kontrollkästchen oder Auswahlkästchen bezeichnet. Wird zur Laufzeit auf das Kästchen geklickt, wird im Kästchen ein Häkchen angezeigt, das durch erneutes Klicken entfernt wird.
Die wichtigste Eigenschaft ist demzufolge die, die den Zustand des Kontrollkästchens mit einem booleschen Wert beschreibt: Checked. Der Wert der Eigenschaft gibt an, ob das Kästchen markiert ist (true) oder nicht (false). Eine Änderung der Auswahl hat die Auslösung des Ereignisses CheckedChanged zur Folge. Sie können das Ereignis dazu benutzen, um im Ereignishandler den neuen Zustand des Kästchens zu überprüfen, um darauf entsprechend zu reagieren.
| private void checkBox1_CheckedChanged(object sender, EventArgs e) {
|
| if (chekBox1.Checked)
|
| // Anweisungen
|
| else
|
| // Anweisungen
|
| }
|
Der Aktivierungszustand wird automatisch umgeschaltet, wenn der Anwender auf das Kontrollkästchen klickt. Wenn Sie das vermeiden wollen, müssen Sie die Eigenschaft AutoCheck auf false setzen. Allerdings sind Sie dann auch in der Pflicht, einen anderen Weg zu finden, der die Umschaltung bewirkt, z.B. im Click-Ereignis des Steuerelements:
| // Ereignishandler des Click-Ereignisses der Checkbox 'chkBox'
|
| private void checkBox1_Click(object sender, EventArgs e) {
|
| chkBox.Checked = !chkBox.Checked;
|
| }
|
Das Fenster im folgenden Beispiel enthält drei Kontrollkästchen, die dazu dienen, den Stil einer Zeichenfolge in einer Textbox in beliebiger Kombination fett, kursiv oder unterstrichen darzustellen.
Hier klicken, um das Bild zu vergrößern
Abbildung 16.5 Ausgabe des Beispiels »CheckBoxDemo«
| // ---------------------------------------------------------
|
| // Beispiel: ...\Kapitel 16\CheckBoxDemo
|
| // ---------------------------------------------------------
|
| public Form1() {
|
| CheckBox[] chkFont = new CheckBox[3];
|
| string[] style ={"Fett", "Kursiv", "Unterstrichen"};
|
| for(int i = 0; i < 3; i++) {
|
| chkFont[i] = new CheckBox();
|
| chkFont[i].Location = new Point(25, 45 + i*25);
|
| chkFont[i].Text = style[i];
|
| chkFont[i].CheckedChanged += new EventHandler(CheckboxChanged);
|
| }
|
| this.Controls.AddRange(chkFont);
|
| InitializeComponent();
|
| }
|
| // Ereignishandler
|
| private void CheckboxChanged(object sender, EventArgs e) {
|
| FontStyle[] fs = {FontStyle.Bold, FontStyle.Italic, FontStyle.Underline};
|
| FontStyle newFontStyle = 0;
|
| for(int i = 0; i < 3; i++) {
|
| if(((CheckBox)this.Controls[i]).Checked)
|
| newFontStyle |= fs[i];
|
| }
|
| textBox1.Font = new Font(textBox1.Font, newFontStyle);
|
| }
|
Bei Auswahlkästchen und den im folgenden Abschnitt beschriebenen Optionsschaltflächen stoßen wir auf ein generelles Problem des Windows Forms-Designers. Enthält eine Form mehrere gleichartige Steuerelemente, stehen diese häufig in einem funktional-logischen Zusammenhang – wie auch in diesem Beispiel. Es bietet sich in solchen Fällen an, diesen Zusammenhang durch ein Steuerelement-Array abzubilden. Mit dem Windows Forms-Designer lassen sich jedoch solche nicht erzeugen. Aus diesem Grund werden die Kontrollkästchen im Code des Form-Konstruktors erzeugt.
Dazu wird zuerst ein Array vom Typ CheckBox deklariert, das drei Elemente enthält:
| CheckBox[] chkFont = new CheckBox[3];
|
Einem zweiten Array vom Typ string werden Zeichenketten zugewiesen, die den Kontrollkästchen als Beschriftung dienen. Alle wesentlichen Eigenschaften der drei Checkboxen können dann in einer Schleife initialisiert werden:
| string[] style ={"Fett", "Kursiv", "Unterstrichen"};
|
| for(int i = 0; i <= 2; i++) {
|
| chkFont[i] = new CheckBox();
|
| chkFont[i].Location = new Point(25, 45 + i * 25);
|
| chkFont[i].Text = style[i];
|
| // Ereignishandler installieren
|
| chkFont[i].CheckedChanged += new EventHandler(CheckboxChanged);
|
| }
|
Beim Klicken auf eine der drei Checkboxen wird das Ereignis CheckChanged ausgelöst. Der Ereignishandler CheckboxChanged ist so implementiert, dass er sich bei den Ereignissen der drei Checkboxen registriert. Nach dem Beenden der Schleife wird das CheckBox-Array mit der Methode AddRange der ControlCollection der Form mit
| this.Controls.AddRange(chkFont);
|
übergeben.
Sehen wir uns nun den Ereignishandler an. Die Mitglieder der Aufzählung FontStyle werden einem Array zugewiesen. Dabei ist zu beachten, dass die Reihenfolge funktionell der des Zeichenfolge-Arrays style entspricht. Damit gewährleisten wir, dass der Zähler der Schleife als Index des Kontrollkästchen-Arrays benutzt werden kann und das richtige Element aus dem FontStyle-Array zugeordnet wird.
| FontStyle[] fs = {FontStyle.Bold, FontStyle.Italic, FontStyle.Underline};
|
Klickt der Anwender zur Laufzeit auf eines der Kontrollkästchen, wird eine Schleife durchlaufen und der Zustand Checked jedes einzelnen Kontrollkästchens überprüft. Innerhalb der Schleife wird der aktuelle Aktivierungszustand aller Auswahlkästchen abgefragt:
| if(((CheckBox)this.Controls[i]).Checked)
|
| ...
|
Obwohl sich mit der Textbox ein weiteres Steuerelement in der Form befindet, dessen Referenz nicht in den Typ CheckBox konvertiert werden kann, wird das if-Statement zu keinem Fehler führen. Es zahlt sich hier für uns aus, dass wir vor dem Aufruf der Initialisierungsroutine InitializeComponent die Checkboxen der ControlCollection hinzugefügt haben und daher deren Index in der Auflistung genau kennen.
Abhängig davon, ob das Kontrollkästchen markiert ist oder nicht, werden die entsprechenden Bits in der Variablen newFontStyle vom Typ FontStyle mit
gesetzt und das Ergebnis nach Beendigung der Schleife dem zweiten Parameter des Font-Konstruktors übergeben.
16.3.1 Eigenschaften eines Kontrollkästchens
Die Beschriftung einer Checkbox erfolgt mit der schon bekannten Eigenschaft Text. Standardmäßig ist das Kästchen im Steuerelement links ausgerichtet, die Beschriftung rechts davon. Über die Eigenschaft CheckAlign kann das Kästchen innerhalb der gesamten Fläche des Steuerelements angeordnet werden:
| public ContentAlignment CheckAlign {get; set;}
|
Die Aufzählung ContentAlignment haben wir im Zusammenhang mit den Schaltflächen schon behandelt (siehe Tabelle 16.4). Der Standard der Textausrichtung eines Kontrollkästchens ist ContentAlignment.MiddleLeft.
Ebenso lässt auch die Beschriftung mit der Eigenschaft TextAlign ausrichten, die vom gleichen Typ ist wie CheckAlign und damit auch dieselben Einstellungen zulässt. Ist man ein Freund von grafischen Symbolen, bietet sich anstelle der Beschriftung oder auch zusätzlich zu dieser an, der Eigenschaft Image eine Bitmap, ein Icon oder ein Metafile anzugeben und dieses mit ImageAlign auszurichten.
Ein Kontrollkästchen muss sich nicht unbedingt als Kästchen darstellen. Über die Eigenschaft Appearance mit der Einstellung
| checkbox1.Appearance = Appearance.Button;
|
kann das Erscheinungsbild auch das einer Schaltfläche sein (der Standard ist Appearance.Normal) Allerdings unterscheidet sich das Verhalten eines so festgelegten Kontrollkästchens von dem eines herkömmlichen Buttons, denn im ausgewählten Zustand bleibt das Kontrollkästchen – besser sollte man jetzt von einem Button sprechen – im gedrückten Zustand. Das entspricht der Einstellung true der Eigenschaft Checked. In Abbildung 16.6 ist das mit checkbox1 beschriftete Steuerelement ausgewählt, das andere nicht.
Hier klicken, um das Bild zu vergrößern
Abbildung 16.6 Kontrollkästchen mit der Einstellung »Appearance.Button«
Die Darstellungsarten einer Auswahlschaltfläche
Sie können, wie Sie eben gesehen haben, eine CheckBox sowohl als Auswahlkästchen oder als Schaltfläche anzeigen lassen. Darüber hinaus gestattet die Eigenschaft FlatStyle weitere Stile (siehe auch Tabelle 16.2). Mit der Einstellung FlatStyle=Flat und Appearance=Button wird auch die Eigenschaft FlatAppearance, die Sie schon im Zusammenhang mit den Buttons kennen gelernt haben, wieder interessant. Zusätzlich zu den Eigenschaften, die der Tabelle 16.3 zu entnehmen sind, können Checkboxen auch eine gewünschte Hintergrundfarbe im ausgewählten Zustand annehmen. Hierzu dient die Eigenschaft CheckedBackColor der Klasse FlatButtonAppearance.
16.3.2 Checkboxen mit drei Aktivierungszuständen
Bisher haben Sie das Kontrollkästchen als ein Steuerelement kennen gelernt, das die beiden Zustände true und false anzeigt. Manchmal ist jedoch ein Steuerelement dieses Typs erforderlich, das einen »Zwischenzustand« beschreibt. Denken Sie beispielsweise an einen markierten Text in einem Textverarbeitungsdokument. In einem Kontrollkästchen, das für die Festlegung der fetten Schrift zuständig ist, wird das Häkchen gesetzt, wenn auch tatsächlich der gesamte markierte Text fett dargestellt wird. Was ist aber, wenn der markierte Text nur teilweise fett geschrieben ist? Das Kästchen deaktiviert zu lassen, spiegelt genauso wenig die Realität wider wie der aktivierte Zustand. Es muss ein Kompromiss in der Darstellung des Kontrollkästchens gefunden werden. Diesem Sonderfall wird mit den beiden Eigenschaften ThreeState und CheckState Rechnung getragen.
Die Eigenschaft ThreeState beschreibt mit einem booleschen Wert, ob das Kontrollkästchen anstatt der üblichen zwei nun drei Aktivierungszustände unterstützt. Der Standard ist false. Um drei mögliche Zustände darzustellen, setzen Sie ThreeState=true. Der aktuelle Zustand des Auswahlkästchens wird danach durch die Eigenschaft CheckState beschrieben, die drei Werte annehmen kann, die mit der gleichnamigen Enumeration beschrieben werden.
Tabelle 16.5 Die Aufzählung »CheckState«
| Member
|
Beschreibung
|
| Unchecked
|
Das Kästchen ist nicht markiert.
|
| Checked
|
Das Kästchen ist markiert.
|
| Intermediate
|
Das Kästchen ist markiert, wird zur Kennzeichnung des Zwischenzustands aber grau hinterlegt.
|
Haben Sie ein Kontrollkästchen, das drei Zustände anzeigen kann, sollten Sie nicht das Ereignis CheckChanged, sondern das Ereignis CheckStateChanged programmieren, das auftritt, wenn sich die CheckState-Eigenschaft ändert. |
